package com.runmi.webchat.aftersale.common.utils;

import org.apache.commons.io.IOUtils;  
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;  
import org.apache.http.HttpStatus;  
import org.apache.http.NameValuePair;
import org.apache.http.auth.AUTH;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.HttpClient;  
import org.apache.http.client.config.RequestConfig;  
import org.apache.http.client.entity.UrlEncodedFormEntity;  
import org.apache.http.client.methods.CloseableHttpResponse;  
import org.apache.http.client.methods.HttpGet;  
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.conn.params.ConnRouteParams;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;  
import org.apache.http.conn.ssl.SSLContextBuilder;  
import org.apache.http.conn.ssl.TrustStrategy;  
import org.apache.http.conn.ssl.X509HostnameVerifier;  
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.auth.BasicScheme;
import org.apache.http.impl.client.BasicAuthCache;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.CloseableHttpClient;  
import org.apache.http.impl.client.DefaultHttpClient;  
import org.apache.http.impl.client.HttpClients;  
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;  
import org.apache.http.util.EntityUtils;


import javax.net.ssl.SSLContext;  
import javax.net.ssl.SSLException;  
import javax.net.ssl.SSLSession;  
import javax.net.ssl.SSLSocket;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;  
import java.io.InputStream;  
import java.nio.charset.Charset;  
import java.security.GeneralSecurityException;  
import java.security.cert.CertificateException;  
import java.security.cert.X509Certificate;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
  
/** 
 * HTTP 请求工具类 
 * 
 * @author : liii 
 * @version : 1.0.0 
 * @date : 2015/7/21 
 * @see : TODO 
 */  
public class HttpUtil {  
  private static PoolingHttpClientConnectionManager connMgr;  
  private static RequestConfig requestConfig;  
  private static final int MAX_TIMEOUT = 7000;  

  static {  
	 
      // 设置连接池  
      connMgr = new PoolingHttpClientConnectionManager();  
      // 设置连接池大小  
      connMgr.setMaxTotal(100);  
      connMgr.setDefaultMaxPerRoute(connMgr.getMaxTotal());  

      RequestConfig.Builder configBuilder = RequestConfig.custom();  
      // 设置连接超时  
      configBuilder.setConnectTimeout(MAX_TIMEOUT);  
      // 设置读取超时  
      configBuilder.setSocketTimeout(MAX_TIMEOUT);  
      // 设置从连接池获取连接实例的超时  
      configBuilder.setConnectionRequestTimeout(MAX_TIMEOUT);  
      // 在提交请求之前 测试连接是否可用  
      configBuilder.setStaleConnectionCheckEnabled(true);  
      requestConfig = configBuilder.build();  
  }  
  
  private static RequestConfig getConfig(HttpProxyInfo proxyInfo){
	  	 
  	//RequestConfig config = RequestConfig.custom().setProxy(proxy).build();  
	  
	  RequestConfig.Builder configBuilder = RequestConfig.custom();  
      // 设置连接超时  
      configBuilder.setConnectTimeout(MAX_TIMEOUT);  
      // 设置读取超时  
      configBuilder.setSocketTimeout(MAX_TIMEOUT);  
      // 设置从连接池获取连接实例的超时  
      configBuilder.setConnectionRequestTimeout(MAX_TIMEOUT);  
      // 在提交请求之前 测试连接是否可用  
      configBuilder.setStaleConnectionCheckEnabled(true);  
      
      if(null!=proxyInfo){
    	  HttpHost proxy = new HttpHost(proxyInfo.getHostProxy(), proxyInfo.getPort(), "http");  
    	  configBuilder.setProxy(proxy);
      }
      RequestConfig requestConfig = configBuilder.build();  
      return requestConfig;
  }

  /** 
   * 发送 GET 请求（HTTP），不带输入数据 
   * @param url 
   * @return 
   */  
  public static String doGet(String url) {  
      return doGet(url, new HashMap<String, Object>());  
  }  

  /** 
   * 发送 GET 请求（HTTP），K-V形式 
   * @param url 
   * @param params 
   * @return 
   */  
  public static String doGet(String url, Map<String, Object> params) {  
      String apiUrl = url;  
      StringBuffer param = new StringBuffer();  
      int i = 0;  
      for (String key : params.keySet()) {  
          if (i == 0)  
              param.append("?");  
          else  
              param.append("&");  
          param.append(key).append("=").append(params.get(key));  
          i++;  
      }  
      apiUrl += param;  
      String result = null;  
       HttpClient httpclient = new DefaultHttpClient();  
       try {  
           HttpGet httpPost = new HttpGet(apiUrl); 	    
           HttpResponse response = httpclient.execute(httpPost);  
           int statusCode = response.getStatusLine().getStatusCode();  
 
           System.out.println("执行状态码 : " + statusCode);  
 
           HttpEntity entity = response.getEntity();  
           if (entity != null) {  
               InputStream instream = entity.getContent();  
               result = IOUtils.toString(instream, "UTF-8");  
           }  
       } catch (IOException e) {  
           e.printStackTrace();  
       }  
       return result;  
   } 

  public static String doGetSSL(String apiUrl,Map<String, Object> params) {  
      CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();  
 
      CloseableHttpResponse response = null;  
      String httpStr = null;  
      
      if(null!=params && params.size()>0){
	      StringBuffer param = new StringBuffer();  
	      int i = 0;  
	      for (String key : params.keySet()) {  
	          if (i == 0)  
	              param.append("?");  
	          else  
	              param.append("&");  
	          param.append(key).append("=").append(params.get(key));  
	          i++;  
	      }  
	      apiUrl += param;  
      }
    
     
      HttpGet httpPost = new HttpGet(apiUrl); 
      try {  
          httpPost.setConfig(requestConfig);     
          SslUtils.ignoreSsl();	    
          response = httpClient.execute(httpPost);  
          int statusCode = response.getStatusLine().getStatusCode();  
          if (statusCode != HttpStatus.SC_OK) {  
              return null;  
          }  
          HttpEntity entity = response.getEntity();  
          if (entity == null) {  
              return null;  
          }  
          httpStr = EntityUtils.toString(entity, "utf-8");  
      } catch (Exception e) {  
          e.printStackTrace();  
      } finally {  
          if (response != null) {  
              try {  
                  EntityUtils.consume(response.getEntity());  
              } catch (IOException e) {  
                  e.printStackTrace();  
              }  
          }  
      }  
      return httpStr;  
  } 
  public static String doGetProxySSL(String apiUrl) {
	return doGetProxySSL(apiUrl,null,null,"utf-8");
  }
  public static String doGetProxySSL(String apiUrl,Map<String, Object> params) {
	return doGetProxySSL(apiUrl,params,null,"utf-8");
  }
  public static String doGetProxySSL(String apiUrl,String charset) {
	return doGetProxySSL(apiUrl,null,null,charset);
  }
  public static String doGetProxySSL(String apiUrl,Map<String, Object> params,Map<String, String> headers,String charset) {  
  
	  HttpProxyInfo proxyInfo= HttpProxyUtil.getNextProxy();
	  RequestConfig requestConfig= getConfig(proxyInfo);
      CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();  
 
      CloseableHttpResponse response = null;  
      String httpStr = null;  
      
      if(null!=params && params.size()>0){
	      StringBuffer param = new StringBuffer();  
	      int i = 0;  
	      for (String key : params.keySet()) {  
	          if (i == 0)  
	              param.append("?");  
	          else  
	              param.append("&");  
	          param.append(key).append("=").append(params.get(key));  
	          i++;  
	      }  
	      apiUrl += param;  
      }
    
     
      HttpGet httpPost = new HttpGet(apiUrl); 
      try {
    	  
    	  if(null!=headers && headers.size()>0){
    		  for (String key : headers.keySet()) {  
    			  httpPost.setHeader(key, headers.get(key).toString());
    	      }  
    	  }
    	    
    	  if(null!=proxyInfo){
	    	  HttpHost proxy = new HttpHost(proxyInfo.getHostProxy(), proxyInfo.getPort());      	   
	    	  BasicScheme proxyAuth = new BasicScheme();  
	    	  // Make client believe the challenge came form a proxy  
	    	  proxyAuth.processChallenge(new BasicHeader(AUTH.PROXY_AUTH, "BASIC realm=default"));  
	    	  BasicAuthCache authCache = new BasicAuthCache();  
	    	  authCache.put(proxy, proxyAuth);  
	    	    
	    	  CredentialsProvider credsProvider = new BasicCredentialsProvider();  
	    	  credsProvider.setCredentials(  
	    	          new AuthScope(proxy),  
	    	          new UsernamePasswordCredentials(proxyInfo.getUserName(), proxyInfo.getPassword()));  
	    	    
	    	  HttpClientContext context = HttpClientContext.create();  
	    	  context.setAuthCache(authCache);  
	    	  context.setCredentialsProvider(credsProvider);    
	    	  httpPost.setConfig(requestConfig);  
	      	  SslUtils.ignoreSsl();	      
	          response = httpClient.execute(httpPost,context);  
    	  }else{
    		  httpPost.setConfig(requestConfig);  
	      	  SslUtils.ignoreSsl();	      
	          response = httpClient.execute(httpPost);  
    	  }
    	         
          int statusCode = response.getStatusLine().getStatusCode();  
          if (statusCode != HttpStatus.SC_OK) {  
              return null;  
          }  
          HttpEntity entity = response.getEntity();  
          if (entity == null) {  
              return null;  
          }  
          httpStr = EntityUtils.toString(entity, charset);  
      } catch (Exception e) {  
          e.printStackTrace();  
      } finally {  
          if (response != null) {  
              try {  
                  EntityUtils.consume(response.getEntity());  
              } catch (IOException e) {  
                  e.printStackTrace();  
              }  
          }  
      }  
      return httpStr;  
  } 
  public static boolean downFile(String url, String destFileName) {  
      // 生成一个httpclient对象  
	  InputStream in=null;
	  boolean result=false;
	  CloseableHttpClient httpclient =null;
	  HttpResponse response =null;
      try {  
    	  HttpProxyInfo proxyInfo= null;
    	  RequestConfig requestConfig= getConfig(null);
    	  httpclient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();  
    	  HttpGet httpget = new HttpGet(url);  
    	  
    	  if(null!=proxyInfo){
	    	  HttpHost proxy = new HttpHost(proxyInfo.getHostProxy(), proxyInfo.getPort());      	   
	    	  BasicScheme proxyAuth = new BasicScheme();  
	    	  // Make client believe the challenge came form a proxy  
	    	  proxyAuth.processChallenge(new BasicHeader(AUTH.PROXY_AUTH, "BASIC realm=default"));  
	    	  BasicAuthCache authCache = new BasicAuthCache();  
	    	  authCache.put(proxy, proxyAuth);  
	    	    
	    	  CredentialsProvider credsProvider = new BasicCredentialsProvider();  
	    	  credsProvider.setCredentials(  
	    	          new AuthScope(proxy),  
	    	          new UsernamePasswordCredentials(proxyInfo.getUserName(), proxyInfo.getPassword()));  
	    	    
	    	  HttpClientContext context = HttpClientContext.create();  
	    	  context.setAuthCache(authCache);  
	    	  context.setCredentialsProvider(credsProvider);    
	    	  httpget.setConfig(requestConfig);  
	      	  SslUtils.ignoreSsl();	      
	          response = httpclient.execute(httpget,context);  
    	  }else{
    		  httpget.setConfig(requestConfig);  
	      	  SslUtils.ignoreSsl();	      
	          response = httpclient.execute(httpget);  
    	  } 	  
    	 // httpclient = HttpClients.createDefault();          
         // HttpResponse response = httpclient.execute(httpget);  
          HttpEntity entity = response.getEntity();  
          in = entity.getContent();  
          File file = new File(destFileName);  
          
          FileOutputStream fout = new FileOutputStream(file);  
          int l = -1;  
          byte[] tmp = new byte[1024];  
          while ((l = in.read(tmp)) != -1) {  
              fout.write(tmp, 0, l);  
              // 注意这里如果用OutputStream.write(buff)的话，图片会失真，大家可以试试  
          }  
          fout.flush();  
          fout.close();  
          result=true;
      } catch (Exception e) {  
    	  e.printStackTrace();
      } finally {  
    	  if(null!=in){
          // 关闭低层流。  
    		  try {
				in.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}  
    	  }
      }  
     try {
    	  if(null!=httpclient){
    		  httpclient.close();
    	  }
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}  
    return result;
  }  
 
   /** 
    * 发送 POST 请求（HTTP），不带输入数据 
    * @param apiUrl 
    * @return 
    */  
   public static String doPost(String apiUrl) {  
       return doPost(apiUrl, new HashMap<String, Object>());  
   }  
 
   /** 
    * 发送 POST 请求（HTTP），K-V形式 
    * @param apiUrl API接口URL 
    * @param params 参数map 
    * @return 
    */  
   public static String doPost(String apiUrl, Map<String, Object> params) {  
       CloseableHttpClient httpClient = HttpClients.createDefault();  
       String httpStr = null;  
       HttpPost httpPost = new HttpPost(apiUrl);  
       CloseableHttpResponse response = null;  
 
       try {  
           httpPost.setConfig(requestConfig);  
           List<NameValuePair> pairList = new ArrayList<>(params.size());  
           for (Map.Entry<String, Object> entry : params.entrySet()) {  
               NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry  
                       .getValue().toString());  
               pairList.add(pair);  
           }  
           httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName("UTF-8")));  
           response = httpClient.execute(httpPost);  
           System.out.println(response.toString());  
           HttpEntity entity = response.getEntity();  
           httpStr = EntityUtils.toString(entity, "UTF-8");  
       } catch (IOException e) {  
           e.printStackTrace();  
       } finally {  
           if (response != null) {  
               try {  
                   EntityUtils.consume(response.getEntity());  
               } catch (IOException e) {  
                   e.printStackTrace();  
               }  
           }  
       }  
       return httpStr;  
   }  
 
   /** 
    * 发送 POST 请求（HTTP），JSON形式 
    * @param apiUrl 
    * @param json json对象 
    * @return 
    */  
   public static String doPost(String apiUrl, Object json) {  
       CloseableHttpClient httpClient = HttpClients.createDefault();  
       String httpStr = null;  
       HttpPost httpPost = new HttpPost(apiUrl);  
       CloseableHttpResponse response = null;  
 
       try {  
           httpPost.setConfig(requestConfig);  
           StringEntity stringEntity = new StringEntity(json.toString(),"UTF-8");//解决中文乱码问题  
           stringEntity.setContentEncoding("UTF-8");  
           stringEntity.setContentType("application/json");  
           httpPost.setEntity(stringEntity);  
           response = httpClient.execute(httpPost);  
           HttpEntity entity = response.getEntity();  
           System.out.println(response.getStatusLine().getStatusCode());  
           httpStr = EntityUtils.toString(entity, "UTF-8");  
       } catch (IOException e) {  
           e.printStackTrace();  
       } finally {  
           if (response != null) {  
               try {  
                   EntityUtils.consume(response.getEntity());  
               } catch (IOException e) {  
                   e.printStackTrace();  
               }  
           }  
       }  
       return httpStr;  
   }  
 
   /** 
    * 发送 SSL POST 请求（HTTPS），K-V形式 
    * @param apiUrl API接口URL 
    * @param params 参数map 
    * @return 
    */  
   public static String doPostSSL(String apiUrl, Map<String, Object> params) {  
       CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();  
       HttpPost httpPost = new HttpPost(apiUrl);  
       CloseableHttpResponse response = null;  
       String httpStr = null;  
 
       try {  
           httpPost.setConfig(requestConfig);  
           List<NameValuePair> pairList = new ArrayList<NameValuePair>(params.size());  
           for (Map.Entry<String, Object> entry : params.entrySet()) {  
               NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry  
                       .getValue().toString());  
               pairList.add(pair);  
           }  
           httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName("utf-8")));  
           response = httpClient.execute(httpPost);  
           int statusCode = response.getStatusLine().getStatusCode();  
           if (statusCode != HttpStatus.SC_OK) {  
               return null;  
           }  
           HttpEntity entity = response.getEntity();  
           if (entity == null) {  
               return null;  
           }  
           httpStr = EntityUtils.toString(entity, "utf-8");  
       } catch (Exception e) {  
           e.printStackTrace();  
       } finally {  
           if (response != null) {  
               try {  
                   EntityUtils.consume(response.getEntity());  
               } catch (IOException e) {  
                   e.printStackTrace();  
               }  
           }  
       }  
       return httpStr;  
   }  
 
   /** 
    * 发送 SSL POST 请求（HTTPS），JSON形式 
    * @param apiUrl API接口URL 
    * @param json JSON对象 
    * @return 
    */  
   public static String doPostSSL(String apiUrl, Object json) {  
       CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();  
       HttpPost httpPost = new HttpPost(apiUrl);  
       CloseableHttpResponse response = null;  
       String httpStr = null;  
 
       try {  
           httpPost.setConfig(requestConfig);  
           StringEntity stringEntity = new StringEntity(json.toString(),"UTF-8");//解决中文乱码问题  
           stringEntity.setContentEncoding("UTF-8");  
           stringEntity.setContentType("application/json");  
           httpPost.setEntity(stringEntity);  
           response = httpClient.execute(httpPost);  
           int statusCode = response.getStatusLine().getStatusCode();  
           if (statusCode != HttpStatus.SC_OK) {  
               return null;  
           }  
           HttpEntity entity = response.getEntity();  
           if (entity == null) {  
               return null;  
           }  
           httpStr = EntityUtils.toString(entity, "utf-8");  
       } catch (Exception e) {  
           e.printStackTrace();  
       } finally {  
           if (response != null) {  
               try {  
                   EntityUtils.consume(response.getEntity());  
               } catch (IOException e) {  
                   e.printStackTrace();  
               }  
           }  
       }  
       return httpStr;  
   }  
 
   /** 
    * 创建SSL安全连接 
    * 
    * @return 
    */  
   private static SSLConnectionSocketFactory createSSLConnSocketFactory() {  
       SSLConnectionSocketFactory sslsf = null;  
       try {  
           SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {  
 
               public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {  
                   return true;  
               }  
           }).build();  
           sslsf = new SSLConnectionSocketFactory(sslContext, new X509HostnameVerifier() {  
 
               @Override  
               public boolean verify(String arg0, SSLSession arg1) {  
                   return true;  
               }  
 
               @Override  
               public void verify(String host, SSLSocket ssl) throws IOException {  
               }  
 
               @Override  
               public void verify(String host, X509Certificate cert) throws SSLException {  
               }  
 
               @Override  
               public void verify(String host, String[] cns, String[] subjectAlts) throws SSLException {  
               }  
           });  
       } catch (GeneralSecurityException e) {  
           e.printStackTrace();  
       }  
       return sslsf;  
   }  
 
 
   /** 
    * 测试方法 
    * @param args 
    */  
   public static void main(String[] args) throws Exception {  
	   long beginTime=System.currentTimeMillis();
	  String html=  doGetProxySSL("https://detail.tmall.com/item.htm?id=553745269452&skuId=3414398044129&user_id=106852162&cat_id=50106425&is_b=1&rn=011b25d66d15c454b44b79742fcc722d",null,null,"utf-8");
	 // System.out.println(html);
	  long endTime=	System.currentTimeMillis();
	    System.out.println(String.format("Execute main !ok consume %s ms", endTime - beginTime));
   }  

}